package com.quyunshuo.module.home.activity.time;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Camera;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.view.animation.DecelerateInterpolator;
import android.widget.FrameLayout;
import android.widget.Scroller;
import android.widget.TextView;

import com.quyunshuo.module.home.R;

import java.util.Calendar;

/**
 * 翻页布局组件
 *
 * 功能：
 * 1. 实现数字翻页动画效果
 * 2. 支持自定义背景、文本大小、颜色
 * 3. 支持向上/向下翻页
 * 4. 支持连续翻页
 *
 * 实现原理：
 * 使用两个TextView叠加：
 * - mVisibleTextView: 当前可见的文本视图
 * - mInvisibleTextView: 准备翻页时使用的文本视图
 *
 * 翻页动画通过Scroller和Camera实现：
 * 1. 使用Scroller控制动画进度
 * 2. 使用Camera实现3D旋转效果
 * 3. 在dispatchDraw中根据进度绘制不同部分
 */
public class FlipLayout extends FrameLayout  {
    private TextView mVisibleTextView; // 当前可见的文本视图
    private TextView mInvisibleTextView; // 不可见的文本视图（用于翻页动画）

    private int layoutWidth; // 布局宽度
    private int layoutHeight; // 布局高度
    private Scroller mScroller; // 滚动控制器，用于控制动画
    private String TAG = "FlipLayout"; // 日志标签
    private String timetag; // 时间标签（用于区分时、分、秒）
    private Camera mCamera = new Camera(); // 相机对象，用于3D效果
    private Matrix mMatrix = new Matrix(); // 矩阵对象，用于变换
    private Rect mTopRect = new Rect(); // 上半部分矩形区域
    private Rect mBottomRect = new Rect(); // 下半部分矩形区域
    private boolean isUp = true; // 翻页方向（true:向上翻，false:向下翻）
    private Paint mminutenePaint = new Paint(); // 阳面绘制画笔
    private Paint mShadePaint = new Paint(); // 阴面绘制画笔
    private boolean isFlipping = false; // 是否正在翻页

    private int maxNumber; // 数字最大值（如秒的最大值是59）
    private int flipTimes = 0; // 需要翻页的次数
    private int timesCount = 0; // 已翻页次数

    private FlipOverListener mFlipOverListener; // 翻页完成监听器

    public FlipLayout(Context context) {
        super(context, null);
    }

    public FlipLayout(Context context, AttributeSet attrs) {
        super(context, attrs, 0);

        // 解析XML属性
        TypedArray array = context.obtainStyledAttributes(attrs, R.styleable.FlipLayout);

        // 获取背景资源ID或颜色
        int resId = array.getResourceId(R.styleable.FlipLayout_flipTextBackground,-1);
        int color = Color.WHITE;
        if(-1 == resId){
            color = array.getColor(R.styleable.FlipLayout_flipTextBackground, Color.WHITE);
        }

        // 获取文本大小（转换为dp）
        float size = array.getDimension(R.styleable.FlipLayout_flipTextSize,36);
        size = px2dip(context,size);

        // 获取文本颜色
        int textColor = array.getColor(R.styleable.FlipLayout_flipTextColor, Color.BLACK);

        array.recycle();

        // 初始化视图
        init(context,resId,color,size,textColor);
    }

    /**
     * 初始化方法
     */
    private void init(Context context, int resId, int color, float size, int textColor) {
        // 创建减速插值器的Scroller
        mScroller = new Scroller(context,new DecelerateInterpolator());

        // 加载自定义字体
        Typeface tf = Typeface.createFromAsset(context.getAssets(), "fonts/Aura.OTF");

        // 初始化不可见文本视图
        mInvisibleTextView = new TextView(context);
        mInvisibleTextView.setTextSize(size);
        mInvisibleTextView.setText("00");
        mInvisibleTextView.setGravity(Gravity.CENTER);
        mInvisibleTextView.setIncludeFontPadding(false); // 不包含字体内边距
        mInvisibleTextView.setTextColor(textColor);
        mInvisibleTextView.setTypeface(tf);
        if(resId == -1){
            mInvisibleTextView.setBackgroundColor(color);
        }else {
            mInvisibleTextView.setBackgroundResource(resId);
        }
        addView(mInvisibleTextView);

        // 初始化可见文本视图
        mVisibleTextView = new TextView(context);
        mVisibleTextView.setTextSize(size);
        mVisibleTextView.setText("00");
        mVisibleTextView.setGravity(Gravity.CENTER);
        mVisibleTextView.setIncludeFontPadding(false);
        mVisibleTextView.setTextColor(textColor);
        mVisibleTextView.setTypeface(tf);
        if(resId == -1){
            mVisibleTextView.setBackgroundColor(color);
        }else {
            mVisibleTextView.setBackgroundResource(resId);
        }
        addView(mVisibleTextView);

        // 初始化画笔
        mShadePaint.setColor(Color.BLACK); // 阴面为黑色
        mShadePaint.setStyle(Paint.Style.FILL);
        mminutenePaint.setColor(Color.WHITE); // 阳面为白色
        mminutenePaint.setStyle(Paint.Style.FILL);
    }

    public FlipLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    /**
     * 像素转dp
     */
    public static float px2dip(Context context, float pxValue){
        final float scale = context.getResources().getDisplayMetrics().density;
        return pxValue / scale +0.5f;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        layoutWidth = MeasureSpec.getSize(widthMeasureSpec);
        layoutHeight = MeasureSpec.getSize(heightMeasureSpec);

        setMeasuredDimension(layoutWidth,layoutHeight);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);

        // 布局所有子视图（覆盖整个区域）
        int count  = getChildCount();
        for(int i=0; i<count; i++){
            View child = getChildAt(i);
            child.layout(0,0,layoutWidth, layoutHeight);
        }

        // 设置上半部分矩形区域
        mTopRect.top = 0;
        mTopRect.left = 0;
        mTopRect.right = getWidth();
        mTopRect.bottom = getHeight() / 2;

        // 设置下半部分矩形区域
        mBottomRect.top = getHeight() / 2;
        mBottomRect.left = 0;
        mBottomRect.right = getWidth();
        mBottomRect.bottom = getHeight();
    }

    @Override
    public void computeScroll() {
        // 空实现，因为我们在dispatchDraw中处理滚动
    }

    /**
     * 核心绘制方法
     */
    @Override
    protected void dispatchDraw(Canvas canvas) {
        super.dispatchDraw(canvas);

        // 如果动画正在进行中
        if(!mScroller.isFinished() && mScroller.computeScrollOffset()){
            // 绘制三部分：上半部分、下半部分和翻页部分
            drawTopHalf(canvas);
            drawBottomHalf(canvas);
            drawFlipHalf(canvas);

            // 请求重绘以继续动画
            postInvalidate();
        } else {
            // 动画结束后的处理
            if(isFlipping){
                // 显示最终视图
                showViews(canvas);
            }

            // 检查动画是否真正结束
            if(mScroller.isFinished() && !mScroller.computeScrollOffset()){
                isFlipping = false;
            }

            // 检查是否还有剩余的翻页次数
            if(timesCount < flipTimes){
                timesCount += 1;

                // 准备下一次翻页
                initTextView();
                isFlipping = true;

                // 启动新的翻页动画（根据剩余次数调整速度）
                mScroller.startScroll(0,0,0,layoutHeight,getAnimDuration(flipTimes - timesCount));
                postInvalidate();
            } else {
                // 所有翻页完成
                timesCount = 0;
                flipTimes = 0;

                // 触发翻页完成回调
                if(null != mFlipOverListener && !isFlipping){
                    mFlipOverListener.onFLipOver(FlipLayout.this);
                }
            }
        }
    }

    /**
     * 显示最终视图（翻页完成后）
     */
    private void showViews(Canvas canvas) {
        // 交换可见和不可见视图的文本
        String current = mVisibleTextView.getText().toString();
        if(mVisibleTextView.getText().toString().length()<2){
            current = "0"+mVisibleTextView.getText().toString();
        }
        String past = mInvisibleTextView.getText().toString();
        if (mInvisibleTextView.getText().toString().length()<2){
            past = "0"+mInvisibleTextView.getText().toString();
        }

        mVisibleTextView.setText(past);
        mInvisibleTextView.setText(current);

        // 绘制最终视图（防止切换抖动）
        drawChild(canvas,mVisibleTextView,0);
    }

    /**
     * 绘制下半部分
     */
    private void drawBottomHalf(Canvas canvas) {
        canvas.save();

        // 裁剪到下半部分区域
        canvas.clipRect(mBottomRect);

        // 根据方向选择要绘制的视图
        View drawView = isUp ? mInvisibleTextView : mVisibleTextView;
        drawChild(canvas,drawView,0);

        canvas.restore();
    }

    /**
     * 绘制上半部分
     */
    private void drawTopHalf(Canvas canvas) {
        canvas.save();

        // 裁剪到上半部分区域
        canvas.clipRect(mTopRect);

        // 根据方向选择要绘制的视图
        View drawView = isUp ? mVisibleTextView : mInvisibleTextView;
        drawChild(canvas,drawView,0);

        canvas.restore();
    }

    /**
     * 绘制翻页部分（核心动画）
     */
    private void drawFlipHalf(Canvas canvas) {
        canvas.save();
        mCamera.save();

        View view = null;
        float deg = getDeg(); // 获取当前旋转角度

        // 根据旋转角度选择视图和旋转方向
        if(deg > 90){
            // 超过90度时，绘制另一面的视图
            canvas.clipRect(isUp ? mTopRect : mBottomRect);
            mCamera.rotateX(isUp ? deg - 180 : -(deg - 180));
            view = mInvisibleTextView;
        } else {
            // 90度以内，绘制当前面的视图
            canvas.clipRect(isUp ? mBottomRect : mTopRect);
            mCamera.rotateX(isUp ? deg : -deg);
            view = mVisibleTextView ;
        }

        // 应用相机变换
        mCamera.getMatrix(mMatrix);
        positionMatrix();
        canvas.concat(mMatrix);

        // 绘制选择的视图
        if(view != null){
            drawChild(canvas,view,0);
        }

        // 绘制翻页时的阴影效果
        drawFlippingShademinutene(canvas);

        mCamera.restore();
        canvas.restore();
    }

    /**
     * 获取当前旋转角度（0-180度）
     */
    private float getDeg() {
        return mScroller.getCurrY() * 1.0f / layoutHeight * 180;
    }

    /**
     * 绘制翻页时的阴面和阳面（增强3D效果）
     */
    private void drawFlippingShademinutene(Canvas canvas) {
        final float degreesFlipped = getDeg();

        if (degreesFlipped < 90) {
            // 小于90度时，绘制阳面（白色）或阴面（黑色）
            final int alpha = getAlpha(degreesFlipped);
            mminutenePaint.setAlpha(alpha);
            mShadePaint.setAlpha(alpha);

            // 根据方向选择绘制区域
            canvas.drawRect(isUp ? mBottomRect : mTopRect, isUp ? mminutenePaint : mShadePaint);
        } else {
            // 大于90度时，绘制阴面（黑色）或阳面（白色）
            final int alpha = getAlpha(Math.abs(degreesFlipped - 180));
            mShadePaint.setAlpha(alpha);
            mminutenePaint.setAlpha(alpha);

            // 根据方向选择绘制区域
            canvas.drawRect(isUp ? mTopRect : mBottomRect, isUp ? mShadePaint : mminutenePaint);
        }
    }

    /**
     * 根据角度计算透明度（0-100）
     */
    private int getAlpha(float degreesFlipped) {
        return (int) ((degreesFlipped / 90f) * 100);
    }

    /**
     * 定位变换矩阵（调整3D效果）
     */
    private void positionMatrix() {
        // 缩放以增强3D效果
        mMatrix.preScale(0.25f, 0.25f);
        mMatrix.postScale(4.0f, 4.0f);

        // 调整位置居中
        mMatrix.preTranslate(-getWidth() / 2, -getHeight() / 2);
        mMatrix.postTranslate(getWidth() / 2, getHeight() / 2);
    }

    /**
     * 初始化隐藏文本视图的值（准备翻页）
     */
    private void initTextView() {
        // 获取当前时间值（根据时间标签）
        int visibleValue = getTime();

        // 计算不可见视图的值（根据翻页方向）
        int invisibleValue = isUp ? visibleValue - 1 : visibleValue;

        // 处理边界值
        if(invisibleValue < 0){
            invisibleValue += maxNumber;
        }
        if(invisibleValue >= maxNumber){
            invisibleValue -= maxNumber;
        }

        // 格式化文本（两位数）
        String value = String.valueOf(invisibleValue);
        if(value.length()<2){
            value = "0" +value;
        }

        // 设置不可见视图的文本
        mInvisibleTextView.setText(value);
    }

    /**
     * 根据剩余翻页次数计算动画时长（实现加速效果）
     */
    private int getAnimDuration(int times) {
        if(times <= 0){
            times = 1;
        }
        // 计算动画时长（剩余次数越多，动画越快）
        int animDuration = 500 - (500-100)/9 * times;
        return animDuration;
    }

    /**
     * 翻页完成监听器接口
     */
    public static interface FlipOverListener{
        void onFLipOver(FlipLayout flipLayout);
    }

    //---------- 公共API ----------

    /**
     * 带动画翻页
     *
     * @param value 需要翻动的次数
     * @param maxnumber 数字最大值（如59）
     * @param timeTAG 时间标签（HOUR/MINUTE/SECOND）
     * @param isMinus 翻页方向（true:向上翻，false:向下翻）
     */
    public void smoothFlip(int value,int maxnumber,String timeTAG, boolean isMinus){
        timetag = timeTAG;
        maxNumber = maxnumber;

        // 不需要翻页时直接回调
        if(value <= 0){
            if(null != mFlipOverListener){
                mFlipOverListener.onFLipOver(FlipLayout.this);
            }
            return;
        }

        // 设置翻页参数
        flipTimes = value;
        this.isUp = isMinus;

        // 准备并启动翻页动画
        initTextView();
        isFlipping = true;
        mScroller.startScroll(0,0,0,layoutHeight,getAnimDuration(flipTimes - timesCount));
        timesCount = 1;
        postInvalidate();
    }

    /**
     * 不带动画翻页（直接设置值）
     */
    public void flip(int value,int maxnumber,String timeTAG){
        timetag = timeTAG;
        maxNumber = maxnumber;

        // 格式化文本（两位数）
        String text = String.valueOf(value);
        if(text.length()<2){
            text="0"+text;
        }

        // 直接设置可见文本
        mVisibleTextView.setText(text);
    }

    // 其他公共方法...
    public void addFlipOverListener(FlipOverListener flipOverListener){
        this.mFlipOverListener = flipOverListener;
    }

    public TextView getmVisibleTextView() {
        return mVisibleTextView;
    }

    // ...其他getter和setter方法...

    /**
     * 获取当前时间值（根据时间标签）
     */
    private int getTime(){
        Calendar now = Calendar.getInstance();
        int hour = now.get(Calendar.HOUR_OF_DAY);
        int min = now.get(Calendar.MINUTE);
        int sec = now.get(Calendar.SECOND);

        // 根据时间标签返回对应值
        switch(timetag){
            case "SECOND": return sec;
            case "MINUTE": return min;
            case "HOUR": return hour;
        }
        return 0;
    }
}